package database

import (
	"context"
	"time"

	"github.com/redis/go-redis/v9"
	"github.com/slrun/callcenter/configs"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

var (
	// DB 全局MySQL连接实例
	DB *gorm.DB

	// RedisClient 全局Redis连接实例
	RedisClient *redis.Client

	// MongoDB 全局MongoDB连接实例
	MongoDB *mongo.Client
)

// InitDB 初始化MySQL数据库连接
func InitDB(cfg *configs.Config) error {
	var err error

	// 配置GORM日志
	logConfig := logger.Config{
		SlowThreshold:             time.Second, // 慢SQL阈值
		LogLevel:                  logger.Info, // 日志级别
		IgnoreRecordNotFoundError: true,        // 忽略记录未找到错误
		Colorful:                  true,        // 彩色输出
	}

	// 连接数据库
	DB, err = gorm.Open(mysql.Open(cfg.Database.DSN), &gorm.Config{
		Logger: logger.New(
			&GormLogger{},
			logConfig,
		),
	})
	if err != nil {
		return err
	}

	// 配置连接池
	sqlDB, err := DB.DB()
	if err != nil {
		return err
	}

	sqlDB.SetMaxOpenConns(cfg.Database.MaxOpenConns)
	sqlDB.SetMaxIdleConns(cfg.Database.MaxIdleConns)
	sqlDB.SetConnMaxLifetime(time.Hour)

	return nil
}

// InitRedis 初始化Redis连接
func InitRedis(cfg *configs.Config) error {
	RedisClient = redis.NewClient(&redis.Options{
		Addr:     cfg.Redis.Addr,
		Password: cfg.Redis.Password,
		DB:       cfg.Redis.DB,
	})

	// 测试连接
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	_, err := RedisClient.Ping(ctx).Result()
	return err
}

// InitMongoDB 初始化MongoDB连接
func InitMongoDB(cfg *configs.Config) error {
	var err error

	// 设置连接选项
	clientOptions := options.Client().ApplyURI(cfg.MongoDB.URI)

	// 连接MongoDB
	MongoDB, err = mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		return err
	}

	// 测试连接
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	err = MongoDB.Ping(ctx, nil)
	return err
}

// CloseDB 关闭MySQL数据库连接
func CloseDB() error {
	if DB != nil {
		sqlDB, err := DB.DB()
		if err != nil {
			return err
		}
		return sqlDB.Close()
	}
	return nil
}

// CloseRedis 关闭Redis连接
func CloseRedis() error {
	if RedisClient != nil {
		return RedisClient.Close()
	}
	return nil
}

// CloseMongoDB 关闭MongoDB连接
func CloseMongoDB() error {
	if MongoDB != nil {
		return MongoDB.Disconnect(context.Background())
	}
	return nil
}

// CloseAllConnections 关闭所有数据库连接
func CloseAllConnections() error {
	// 关闭MySQL连接
	if err := CloseDB(); err != nil {
		return err
	}

	// 关闭Redis连接
	if err := CloseRedis(); err != nil {
		return err
	}

	// 关闭MongoDB连接
	if err := CloseMongoDB(); err != nil {
		return err
	}

	return nil
}